// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <math.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, int len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         memory_write, &buffer_ptr, buffer, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     output_bin.data = malloc(pcm_bin.size * 2);  // 假设输出大小不会超过输入的两倍
//     output_bin.size = pcm_bin.size * 2;

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 48000;  // 默认采样率
//     int channels = 2;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         free(output_bin.data);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     ERL_NIF_TERM output_term = enif_make_binary(env, &output_bin);
//     free(output_bin.data);
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)

// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <math.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, int len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .seek = NULL,
//         .tell = NULL,
//         .flush = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     output_bin.data = malloc(pcm_bin.size * 2);  // 假设输出大小不会超过输入的两倍
//     output_bin.size = pcm_bin.size * 2;

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 48000;  // 默认采样率
//     int channels = 2;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         free(output_bin.data);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     ERL_NIF_TERM output_term = enif_make_binary(env, &output_bin);
//     free(output_bin.data);
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <math.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return NULL; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, int len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .seek = NULL,
//         .tell = NULL,
//         .flush = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     output_bin.data = malloc(pcm_bin.size * 2);  // 假设输出大小不会超过输入的两倍
//     output_bin.size = pcm_bin.size * 2;

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 48000;  // 默认采样率
//     int channels = 2;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         free(output_bin.data);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     ERL_NIF_TERM output_term = enif_make_binary(env, &output_bin);
//     free(output_bin.data);
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <math.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .close = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     output_bin.data = malloc(pcm_bin.size * 2);  // 假设输出大小不会超过输入的两倍
//     output_bin.size = pcm_bin.size * 2;

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 16000;  // 默认采样率
//     int channels = 1;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         free(output_bin.data);
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     ERL_NIF_TERM output_term = enif_make_binary(env, &output_bin);
//     free(output_bin.data);
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .close = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     unsigned char* output_data = enif_make_new_binary(env, pcm_bin.size * 2, &output_bin);
//     CHECK_NULL(output_data, "Failed to allocate output buffer");

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 16000;  // 默认采样率
//     int channels = 1;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), enif_make_binary(env, &output_bin));
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)



// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .close = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     ERL_NIF_TERM output_term;
//     unsigned char* output_data = enif_make_new_binary(env, pcm_bin.size * 2, &output_term);
//     CHECK_NULL(output_data, "Failed to allocate output buffer");

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 16000;  // 默认采样率
//     int channels = 1;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .close = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     ERL_NIF_TERM output_term;
//     unsigned char* output_data = enif_make_new_binary(env, pcm_bin.size * 2, &output_term);
//     CHECK_NULL(output_data, "Failed to allocate output buffer");

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 16000;  // 默认采样率
//     int channels = 1;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)



// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .close = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     ERL_NIF_TERM output_term;
//     unsigned char* output_data = enif_make_new_binary(env, pcm_bin.size * 2, &output_term);
//     CHECK_NULL(output_data, "Failed to allocate output buffer");

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 16000;  // 默认采样率
//     int channels = 1;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <math.h>

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .close = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     output->data = malloc(output->size);
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     int sample_rate = 16000;  // 默认采样率
//     int channels = 1;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 创建一个新的二进制数据
//     ERL_NIF_TERM output_term;
//     unsigned char* output_data = enif_make_new_binary(env, output_bin.size, &output_term);
//     memcpy(output_data, output_bin.data, output_bin.size);
//     free(output_bin.data);

//     // 返回 OPUS 二进制流
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// #define READ_SIZE 256

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .close = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     int ret = ope_encoder_write(enc, (const opus_int16*)pcm_data->data, pcm_data->size / 2);
//     CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     ERL_NIF_TERM output_term;
//     unsigned char* output_data = enif_make_new_binary(env, pcm_bin.size * 2, &output_term);
//     CHECK_NULL(output_data, "Failed to allocate output buffer");

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 44100;  // 默认采样率
//     int channels = 2;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)


// #include <erl_nif.h>
// #include <opus/opusenc.h>
// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>

// #define READ_SIZE 256

// // 定义错误处理宏
// #define CHECK_NULL(ptr, msg) \
//     if (!(ptr)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// #define CHECK_ERROR(cond, msg) \
//     if (!(cond)) { \
//         fprintf(stderr, "Error: %s\n", msg); \
//         return -1; \
//     }

// // 内存写入回调函数
// static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
//     // 将数据写入内存缓冲区
//     unsigned char** buffer = (unsigned char**)user_data;
//     memcpy(*buffer, ptr, len);
//     *buffer += len;  // 移动指针
//     return len;
// }

// // 编码 PCM 数据为 OPUS 流
// static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
//     int error = 0;

//     // 创建 Opus 注释
//     OggOpusComments* comments = ope_comments_create();
//     ope_comments_add(comments, "ARTIST", "Unknown Artist");
//     ope_comments_add(comments, "TITLE", "Unknown Track");

//     // 创建回调结构体
//     OpusEncCallbacks callbacks = {
//         .write = memory_write,
//         .close = NULL
//     };

//     // 打开内存编码器
//     unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
//     unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
//     OggOpusEnc* enc = ope_encoder_create_callbacks(
//         &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
//     );
//     CHECK_NULL(enc, "Failed to create Opus encoder");

//     // 编码 PCM 数据
//     size_t total_size = pcm_data->size;
//     size_t offset = 0;
//     while (offset < total_size) {
//         size_t read_size = (total_size - offset < READ_SIZE * 2 * sizeof(short)) ? (total_size - offset) : (READ_SIZE * 2 * sizeof(short));
//         short buf[READ_SIZE * 2];
//         memcpy(buf, pcm_data->data + offset, read_size);
//         int ret = ope_encoder_write(enc, buf, read_size / (2 * sizeof(short)));
//         CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");
//         offset += read_size;
//     }

//     // 完成编码
//     ope_encoder_drain(enc);
//     ope_encoder_destroy(enc);
//     ope_comments_destroy(comments);

//     // 将编码后的数据复制到输出缓冲区
//     output->size = buffer_ptr - buffer;
//     memcpy(output->data, buffer, output->size);

//     return 0;
// }

// // 定义 NIF 函数
// static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
//     ErlNifBinary pcm_bin;
//     ErlNifBinary output_bin;

//     // 获取输入的 PCM 二进制流
//     if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
//         return enif_make_badarg(env);
//     }

//     // 初始化输出的 OPUS 二进制流
//     ERL_NIF_TERM output_term;
//     unsigned char* output_data = enif_make_new_binary(env, pcm_bin.size * 2, &output_term);
//     CHECK_NULL(output_data, "Failed to allocate output buffer");

//     // 编码 PCM 数据为 OPUS 流
//     int sample_rate = 16000;  // 默认采样率
//     int channels = 1;         // 默认声道数
//     if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
//         return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
//     }

//     // 返回 OPUS 二进制流
//     return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
// }

// // NIF 初始化函数
// static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
//     return 0;
// }

// // NIF 卸载函数
// static void unload(ErlNifEnv* env, void* priv_data) {
// }

// // NIF 函数表
// static ErlNifFunc nif_funcs[] = {
//     {"pcm_to_opus", 1, pcm_to_opus_nif}
// };

// // NIF 模块定义
// ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)


#include <erl_nif.h>
#include <opus/opusenc.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define READ_SIZE 256

// 定义错误处理宏
#define CHECK_NULL(ptr, msg) \
    if (!(ptr)) { \
        fprintf(stderr, "Error: %s\n", msg); \
        return -1; \
    }

#define CHECK_ERROR(cond, msg) \
    if (!(cond)) { \
        fprintf(stderr, "Error: %s\n", msg); \
        return -1; \
    }

// 内存写入回调函数
static int memory_write(void* user_data, const unsigned char* ptr, opus_int32 len) {
    // 将数据写入内存缓冲区
    unsigned char** buffer = (unsigned char**)user_data;
    memcpy(*buffer, ptr, len);
    *buffer += len;  // 移动指针
    return len;
}

// 编码 PCM 数据为 OPUS 流
static int pcm_to_opus(ErlNifEnv* env, ErlNifBinary* pcm_data, ErlNifBinary* output, int sample_rate, int channels) {
    int error = 0;

    // 创建 Opus 注释
    OggOpusComments* comments = ope_comments_create();
    ope_comments_add(comments, "ARTIST", "Unknown Artist");
    ope_comments_add(comments, "TITLE", "Unknown Track");

    // 创建回调结构体
    OpusEncCallbacks callbacks = {
        .write = memory_write,
        .close = NULL
    };

    // 打开内存编码器
    unsigned char buffer[1024 * 1024];  // 1MB 缓冲区
    unsigned char* buffer_ptr = buffer;  // 指向缓冲区的指针
    OggOpusEnc* enc = ope_encoder_create_callbacks(
        &callbacks, &buffer_ptr, comments, sample_rate, channels, 0, &error
    );
    CHECK_NULL(enc, "Failed to create Opus encoder");

    // 编码 PCM 数据
    size_t total_size = pcm_data->size;
    size_t offset = 0;
    while (offset < total_size) {
        size_t read_size = (total_size - offset < READ_SIZE * 2 * sizeof(short)) ? (total_size - offset) : (READ_SIZE * 2 * sizeof(short));
        short buf[READ_SIZE * 2];
        memcpy(buf, pcm_data->data + offset, read_size);
        int ret = ope_encoder_write(enc, buf, read_size / (2 * sizeof(short)));
        CHECK_ERROR(ret == 0, "Failed to write data to Opus encoder");
        offset += read_size;
    }

    // 完成编码
    ope_encoder_drain(enc);
    ope_encoder_destroy(enc);
    ope_comments_destroy(comments);

    // 将编码后的数据复制到输出缓冲区
    output->size = buffer_ptr - buffer;
    memcpy(output->data, buffer, output->size);

    return 0;
}

// 定义 NIF 函数
static ERL_NIF_TERM pcm_to_opus_nif(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]) {
    ErlNifBinary pcm_bin;
    ErlNifBinary output_bin;

    // 获取输入的 PCM 二进制流
    if (!enif_inspect_binary(env, argv[0], &pcm_bin)) {
        return enif_make_badarg(env);
    }

    // 初始化输出的 OPUS 二进制流
    ERL_NIF_TERM output_term;
    unsigned char* output_data = enif_make_new_binary(env, pcm_bin.size * 2, &output_term);
    CHECK_NULL(output_data, "Failed to allocate output buffer");

    // 编码 PCM 数据为 OPUS 流
    int sample_rate = 44100;  // 默认采样率
    int channels = 2;         // 默认声道数
    if (pcm_to_opus(env, &pcm_bin, &output_bin, sample_rate, channels) != 0) {
        return enif_make_tuple2(env, enif_make_atom(env, "error"), enif_make_string(env, "Failed to transcode PCM to Opus", ERL_NIF_LATIN1));
    }

    // 返回 OPUS 二进制流
    return enif_make_tuple2(env, enif_make_atom(env, "ok"), output_term);
}

// NIF 初始化函数
static int load(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info) {
    return 0;
}

// NIF 卸载函数
static void unload(ErlNifEnv* env, void* priv_data) {
}

// NIF 函数表
static ErlNifFunc nif_funcs[] = {
    {"pcm_to_opus", 1, pcm_to_opus_nif}
};

// NIF 模块定义
ERL_NIF_INIT(Elixir.SockWorkstation.PcmToOpusNif, nif_funcs, &load, NULL, NULL, &unload)
